def test_action_registry_can_resolve_same_name_classes():
mocker = Mocker()
class MyActionSameName(ActionBase):
regex = r'I do (\w+) very well'
def execute(self, context, *args, **kw):
pass
Temp1 = MyActionSameName
class MyActionSameName(ActionBase):
regex = r'I do (\w+) very bad'
def execute(self, context, *args, **kw):
pass
Temp2 = MyActionSameName
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result('^$')
with mocker:
Action1, args1, kwargs1 = ActionRegistry.suitable_for(
'I do test very well', 'en-us', getter=language_getter_mock)
Action2, args2, kwargs2 = ActionRegistry.suitable_for(
'I do test very bad', 'en-us', getter=language_getter_mock)
assert Action1 is not MyActionSameName
assert Action1 is not Temp2
assert Action1 is Temp1
assert Action2 is Temp2
assert Action2 is MyActionSameName
def test_server_start_stop_metrics(self):
"""Test start/stop metrics."""
mocker = Mocker()
service_meter = mocker.mock(name='meter')
self.service.metrics = service_meter
revno = mocker.mock(name='revno')
self.patch(metrics.services, 'revno', revno)
service_meter.meter('server_stop')
service_meter.decrement('services_active')
service_meter.meter('server_start')
service_meter.increment('services_active')
service_meter.timing("busy.ping", ANY)
mocker.count(0, None)
revno()
mocker.count(0, None)
service_meter.connection
mocker.result(None)
with mocker:
yield self.service.stopService()
yield self.service.startService()
def test_find_match_matched(self):
key = "chr1:154000-230000"
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container = mocker.mock()
container.keys()
mocker.result([key])
container[key]
mocker.result(junction)
mocker.count(1, None)
mocker.replay()
self.common, self.diff = jc.findMatch(container, container)
self.assertEqual(self.common.keys(), ["chr1:154000-230000"])
self.assertEqual(self.diff.keys(), [])
mocker.restore()
mocker.verify()
def test_find_match_not_matched(self):
key1 = "chr1:154000-230000"
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def setUpZope(self, app, configurationContext):
# Mock postmonkey
mocker = Mocker()
postmonkey = mocker.replace("postmonkey")
mailchimp = postmonkey.PostMonkey(ANY)
mocker.count(0, 1000)
# Lists
mailchimp.lists()
mocker.count(0, 1000)
mocker.result({
u'total':
2,
u'data': [
{
u'id': 625,
u'web_id': 625,
u'name': u'ACME Newsletter',
u'default_from_name': u'*****@*****.**',
},
{
u'id': 626,
u'web_id': 626,
u'name': u'ACME Newsletter 2',
u'default_from_name': u'*****@*****.**',
},
]
})
mocker.replay()
# Load ZCML
import example.tdd
xmlconfig.file('configure.zcml',
example.tdd,
context=configurationContext)
def test_find_match_not_matched(self):
key1 = 'chr1:154000-230000'
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result([key1])
container1[key1]
mocker.result(junction)
container2[key1]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [])
self.assertEqual(self.diff.keys(), [key1])
mocker.restore()
mocker.verify()
def test_pyccuracy_core_run_tests():
mocker = Mocker()
context_mock, fso_mock = make_context_and_fso_mocks(mocker)
context_mock.settings.write_report
mocker.result(False)
suite_mock = mocker.mock()
suite_mock.no_story_header
mocker.result([])
suite_mock.stories
mocker.result(['some story'])
runner_mock = mocker.mock()
parser_mock = mocker.mock()
parser_mock.used_actions
mocker.count(min=1, max=None)
mocker.result([])
results_mock = mocker.mock()
results_mock.summary_for('en-us')
mocker.result('my results')
parser_mock.get_stories(ANY)
mocker.result(suite_mock)
runner_mock.run_stories(KWARGS)
mocker.result(results_mock)
with mocker:
pc = PyccuracyCore(parser_mock, runner_mock)
#TODO: falha
results = pc.run_tests(should_throw=False, context=context_mock, fso=fso_mock)
assert results == results_mock, results
def test_server_start_stop_metrics(self):
"""Test start/stop metrics."""
mocker = Mocker()
service_meter = mocker.mock(name='meter')
self.service.metrics = service_meter
revno = mocker.mock(name='revno')
self.patch(metrics.services, 'revno', revno)
service_meter.meter('server_stop')
service_meter.decrement('services_active')
service_meter.meter('server_start')
service_meter.increment('services_active')
service_meter.timing("busy.ping", ANY)
mocker.count(0, None)
revno()
mocker.count(0, None)
service_meter.connection
mocker.result(None)
with mocker:
yield self.service.stopService()
yield self.service.startService()
def setUpZope(self, app, configurationContext):
# Mock postmonkey
mocker = Mocker()
postmonkey = mocker.replace("postmonkey")
mailchimp = postmonkey.PostMonkey(ANY)
mocker.count(0, 1000)
# Lists
mailchimp.lists()
mocker.count(0, 1000)
mocker.result({
u'total': 2,
u'data': [{
u'id': 625,
u'web_id': 625,
u'name': u'ACME Newsletter',
u'default_from_name': u'*****@*****.**',
},
{
u'id': 626,
u'web_id': 626,
u'name': u'ACME Newsletter 2',
u'default_from_name': u'*****@*****.**',
},
]})
mocker.replay()
# Load ZCML
import example.tdd
xmlconfig.file(
'configure.zcml',
example.tdd,
context=configurationContext
)
def test_element_click_action_calls_the_right_browser_driver_methods():
mocker = Mocker()
context = FakeContext(mocker)
context.browser_driver.resolve_element_key(context, "button", "some")
mocker.result("btnSome")
context.browser_driver.is_element_visible("btnSome")
mocker.result(True)
context.browser_driver.click_element("btnSome")
context.language.format("element_is_visible_failure", "button", "some")
mocker.result("button")
context.language.get("button_category")
mocker.count(min=0, max=None)
mocker.result("button")
with mocker:
action = ElementClickAction()
action.execute(context,
element_name="some",
element_type="button",
should_wait=None)
def test_pyccuracy_core_run_tests_works_when_None_Result_returned_from_story_runner():
mocker = Mocker()
context_mock, fso_mock = make_context_and_fso_mocks(mocker)
context_mock.settings.write_report
mocker.result(False)
suite_mock = mocker.mock()
suite_mock.no_story_header
mocker.result([])
suite_mock.stories
mocker.result(['some story'])
runner_mock = mocker.mock()
parser_mock = mocker.mock()
parser_mock.used_actions
mocker.count(min=1, max=None)
mocker.result([])
parser_mock.get_stories(ANY)
mocker.result(suite_mock)
runner_mock.run_stories(KWARGS)
mocker.result(None)
with mocker:
pc = PyccuracyCore(parser_mock, runner_mock)
assert pc.run_tests(should_throw=False, context=context_mock, fso=fso_mock) == None
def test_execute_action_will_not_execute_itself():
mocker = Mocker()
class DoSomethingRecursiveAction(ActionBase):
regex = r'^(And )?I do "(?P<what>\w+)" stuff$'
def execute(self, context, getter_mock, *args, **kwargs):
self.execute_action('And I do "recursive" stuff',
context,
getter=getter_mock)
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result('^$')
context_mock = Object(settings=mocker.mock())
context_mock.settings.default_culture
mocker.result("en-us")
with mocker:
dosaction = DoSomethingRecursiveAction()
args = []
kwargs = dict(what='nothing')
dosaction.execute(context_mock,
getter_mock=language_getter_mock,
*args,
**kwargs)
def test_find_match_matched(self):
key = 'chr1:154000-230000'
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container = mocker.mock()
container.keys()
mocker.result([key])
container[key]
mocker.result(junction)
mocker.count(1, None)
mocker.replay()
self.common, self.diff = jc.findMatch(container, container)
self.assertEqual(self.common.keys(), ['chr1:154000-230000'])
self.assertEqual(self.diff.keys(), [])
mocker.restore()
mocker.verify()
def test_offset(self):
"""
Test that, if the server's BEGIN_CONTENT message specifies an offset,
the file to be uploaded is seek'ed to the right position.
"""
offset = 23
mocker = Mocker()
transport = mocker.mock()
transport.registerProducer(ANY, streaming=True)
transport.write(ANY)
mocker.count(1, None) # I don't really care how many times
fd = mocker.mock()
fd.seek(offset) # this is really all I care about
fd.read(ANY)
mocker.result('')
mocker.replay()
protocol = StorageClient()
protocol.transport = transport
pc = PutContent(protocol, 'share', 'node', '', '', 0, 0, 0, fd)
message = protocol_pb2.Message()
message.type = protocol_pb2.Message.BEGIN_CONTENT
message.begin_content.offset = offset
pc.start()
pc.processMessage(message)
def test_execute_action_will_not_execute_itself():
mocker = Mocker()
class DoSomethingRecursiveAction(ActionBase):
regex = r'^(And )?I do "(?P<what>\w+)" stuff$'
def execute(self, context, getter_mock, *args, **kwargs):
self.execute_action('And I do "recursive" stuff', context, getter=getter_mock)
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result("^$")
context_mock = Object(settings=mocker.mock())
context_mock.settings.default_culture
mocker.result("en-us")
with mocker:
dosaction = DoSomethingRecursiveAction()
args = []
kwargs = dict(what="nothing")
dosaction.execute(context_mock, getter_mock=language_getter_mock, *args, **kwargs)
def test_init_with_serial():
m = Mocker()
kvo_class = m.replace(mod, 'KVOList')
deserialize = m.method(Project.deserialize)
reset_cache = m.method(Project.reset_serial_cache)
docs = kvo_class.alloc().init() >> []
deserialize("<serial>")
reset_cache(); m.count(2)
with m:
proj = Project.alloc().init_with_serial("<serial>")
def unpickle_mocked_task(begins):
mocker = Mocker()
ret = mocker.mock()
ret.overlaps(ANY)
mocker.result(False)
mocker.count(0, None)
ret.begins
mocker.result(begins)
mocker.count(0, None)
mocker.replay()
return ret
def test_init_with_serial():
m = Mocker()
kvo_class = m.replace(mod, 'KVOList')
deserialize = m.method(Project.deserialize)
reset_cache = m.method(Project.reset_serial_cache)
docs = kvo_class.alloc().init() >> []
deserialize("<serial>")
reset_cache()
m.count(2)
with m:
proj = Project.alloc().init_with_serial("<serial>")
def test_healthcheck_returns_204_if_the_mysql_server_is_on(self):
mocker = Mocker()
obj = mocker.replace("mysqlapi.api.models.DatabaseManager.is_up")
obj()
mocker.result(True)
mocker.count(1, 2)
mocker.replay()
request = RequestFactory().get("/resources/g8mysql/status/")
view = Healthcheck()
fake = mocks.FakeEC2Client()
view._client = fake
response = view.get(request, "g8mysql")
self.assertEqual(204, response.status_code)
mocker.verify()
def test_wait_for_disappear_works_even_when_is_visible_raises():
mocker = Mocker()
context = Context(Settings())
selenium_mock = mocker.mock()
selenium_mock.is_element_present('some element')
mocker.count(min=1, max=None)
mocker.result(True)
selenium_mock.is_visible('some element')
mocker.throw(Exception("ERROR: Element some element not found"))
with mocker:
driver = SeleniumDriver(context, selenium=selenium_mock)
driver.wait_for_element_to_disappear("some element", 1)
def test_wait_for_disappear():
mocker = Mocker()
context = Context(Settings())
selenium_mock = mocker.mock()
selenium_mock.is_element_present('some element')
mocker.count(min=1, max=None)
mocker.result(True)
selenium_mock.is_visible('some element')
mocker.count(min=1, max=None)
mocker.result(True)
with mocker:
driver = SeleniumDriver(context, selenium=selenium_mock)
driver.wait_for_element_to_disappear("some element", 1)
def test_action_registry_suitable_for_raises_when_language_getter_can_not_resolve():
mocker = Mocker()
class MyActionLanguage(ActionBase):
regex = LanguageItem("foo_bar_regex1")
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(LanguageItem("foo_bar_regex1"))
mocker.result(None)
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result("^$")
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for("Something blabla", "en-us", getter=language_getter_mock)
def test_action_registry_suitable_for_returns_my_action_without_language_item():
mocker = Mocker()
class MyActionNoLanguage(ActionBase):
regex = r"^I do (\w+)\s(\w+) so proudly$"
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result("^$")
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for(
"I do unit test so proudly", "en-us", getter=language_getter_mock
)
assert Action is MyActionNoLanguage
def test_action_registry_suitable_for_returns_my_action():
mocker = Mocker()
class MyAction(ActionBase):
regex = LanguageItem("foo_bar_regex")
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(LanguageItem("foo_bar_regex"))
mocker.result("My regex .+")
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result("^$")
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for("My regex baz", "en-us", getter=language_getter_mock)
assert Action is MyAction
def test_action_registry_suitable_for_returns_my_action_without_language_item(
):
mocker = Mocker()
class MyActionNoLanguage(ActionBase):
regex = r'^I do (\w+)\s(\w+) so proudly$'
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result('^$')
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for(
'I do unit test so proudly', 'en-us', getter=language_getter_mock)
assert Action is MyActionNoLanguage
def test_action_registry_suitable_for_raises_when_language_getter_can_not_resolve(
):
mocker = Mocker()
class MyActionLanguage(ActionBase):
regex = LanguageItem('foo_bar_regex1')
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(LanguageItem('foo_bar_regex1'))
mocker.result(None)
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result('^$')
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for(
'Something blabla', 'en-us', getter=language_getter_mock)
def test_action_registry_suitable_for_returns_my_action():
mocker = Mocker()
class MyAction(ActionBase):
regex = LanguageItem('foo_bar_regex')
def execute(self, context, *args, **kw):
pass
language_getter_mock = mocker.mock()
language_getter_mock.get(LanguageItem('foo_bar_regex'))
mocker.result('My regex .+')
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result('^$')
with mocker:
Action, args, kwargs = ActionRegistry.suitable_for(
'My regex baz', 'en-us', getter=language_getter_mock)
assert Action is MyAction
def test_wait_for_disappear(self):
mocker = Mocker()
context = Context(Settings())
browser_mock = mocker.mock()
browser_mock.find_by_xpath('some element')
mocker.count(min=1, max=None)
element_mock = mocker.mock()
mocker.result(element_mock)
element_mock.visible
mocker.result(True)
mocker.count(min=1, max=None)
mocker.result(True)
element_mock.visible
mocker.result(False)
mocker.count(min=2, max=None)
mocker.result(True)
with mocker:
driver = SplinterDriver(context, browser=browser_mock)
driver.wait_for_element_to_disappear("some element", 1)
def test_element_click_action_calls_the_right_browser_driver_methods():
mocker = Mocker()
context = FakeContext(mocker)
context.browser_driver.resolve_element_key(context, "button", "some")
mocker.result("btnSome")
context.browser_driver.is_element_visible("btnSome")
mocker.result(True)
context.browser_driver.click_element("btnSome")
context.language.format("element_is_visible_failure", "button", "some")
mocker.result("button")
context.language.get("button_category")
mocker.count(min=0, max=None)
mocker.result("button")
with mocker:
action = ElementClickAction()
action.execute(context, element_name="some", element_type="button", should_wait=None)
def test_find_match_match_not_match(self):
key1 = ["chr1:154000-230000", "chr1:155000-230000"]
key2 = ["chr1:154000-230000"]
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result(key1)
container1[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container1[key1[1]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[1]]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [key1[0]])
self.assertEqual(self.diff.keys(), [key1[1]])
mocker.restore()
mocker.verify()
def test_shared_exon(self):
mocker = Mocker()
self.model = mocker.mock()
self.model.blockStarts
mocker.result([100, 400, 700])
mocker.count(2, None)
self.model.blockSizes
mocker.result([100, 100, 100])
mocker.count(1, None)
self.model.chrom
mocker.result('chr1')
mocker.count(2, None)
self.model.start
mocker.result(0)
mocker.count(1, None)
self.junctions1 = mocker.mock()
self.junctions2 = mocker.mock()
self.junc1 = [400]
self.junc2 = [700]
juncKey = 'chr1:200'
self.junctions1[juncKey]
mocker.result(self.junc1)
self.junctions2[juncKey]
mocker.result(self.junc2)
juncKey = 'chr1:500'
self.junctions1[juncKey]
mocker.throw(KeyError)
juncKey = 'chr1:800'
self.junctions1[juncKey]
mocker.throw(KeyError)
mocker.replay()
self.sharedExons = {}
jc.scanJunctions(self.model, self.junctions1, self.junctions2,
self.sharedExons)
for j in self.sharedExons:
self.assertEqual(self.sharedExons[j], [400])
self.assertEqual(j, 'chr1:200')
def test_find_match_match_not_match(self):
key1 = ['chr1:154000-230000', 'chr1:155000-230000']
key2 = ['chr1:154000-230000']
mocker = Mocker()
junction = mocker.mock()
junction.coverage
mocker.result(40)
mocker.count(1, None)
container1 = mocker.mock()
container2 = mocker.mock()
container1.keys()
mocker.result(key1)
container1[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container1[key1[1]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[0]]
mocker.result(junction)
mocker.count(1, None)
container2[key1[1]]
mocker.throw(KeyError)
mocker.count(1)
mocker.replay()
self.common, self.diff = jc.findMatch(container1, container2)
self.assertEqual(self.common.keys(), [key1[0]])
self.assertEqual(self.diff.keys(), [key1[1]])
mocker.restore()
mocker.verify()
def do_run_tests_should_throw():
mocker = Mocker()
context_mock, fso_mock = make_context_and_fso_mocks(mocker)
context_mock.settings.write_report
mocker.result(False)
context_mock.language = mocker.mock()
context_mock.language.key
mocker.result("key")
results_mock = mocker.mock()
results_mock.summary_for('en-us')
mocker.result('')
results_mock.get_status()
mocker.result(Status.Failed)
suite_mock = mocker.mock()
suite_mock.no_story_header
mocker.result([])
suite_mock.stories
mocker.result(['some story'])
runner_mock = mocker.mock()
parser_mock = mocker.mock()
parser_mock.used_actions
mocker.count(min=1, max=None)
mocker.result([])
parser_mock.get_stories(ANY)
mocker.result(suite_mock)
runner_mock.run_stories(KWARGS)
mocker.result(results_mock)
with mocker:
pc = PyccuracyCore(parser_mock, runner_mock)
pc.run_tests(should_throw=True, context=context_mock, fso=fso_mock)
def test_getThing_with_next(self):
from collective.flattr.browser.flattr import Flattr
mocker = Mocker()
view = Flattr(self.portal, self.layer['request'])
obj = mocker.patch(view)
obj.opener
mocker.result(MockOpener('[ { "type": "thing", "resource": "https://api.flattr.dev/rest/v2/things/1", "link": "https://flattr.dev/thing/1", "id": 1 }, { "type": "thing", "resource": "https://api.flattr.dev/rest/v2/things/2", "link": "https://flattr.dev/thing/2", "id": 2} ]', verify_data=lambda x: 'count=30&page=' in x.get_data()))
mocker.count(2)
# if the same thing is called twice, it is called for the first page
# and again for the second page. So there is a result, what means that
# there is a next page
with mocker:
ret = view.getThings()
self.failUnless(u'data' in ret)
self.failUnless(u'next_page' in ret)
self.assertTrue(ret['next_page'])
self.assertEquals(ret['data'][0], { "type": "thing", "resource": "https://api.flattr.dev/rest/v2/things/1", "link": "https://flattr.dev/thing/1", "id": 1 })
self.assertEquals(ret['data'][1], { "type": "thing", "resource": "https://api.flattr.dev/rest/v2/things/2", "link": "https://flattr.dev/thing/2", "id": 2})
def test_action_registry_can_resolve_same_name_classes():
mocker = Mocker()
class MyActionSameName(ActionBase):
regex = r"I do (\w+) very well"
def execute(self, context, *args, **kw):
pass
Temp1 = MyActionSameName
class MyActionSameName(ActionBase):
regex = r"I do (\w+) very bad"
def execute(self, context, *args, **kw):
pass
Temp2 = MyActionSameName
language_getter_mock = mocker.mock()
language_getter_mock.get(ANY)
mocker.count(min=1, max=None)
mocker.result("^$")
with mocker:
Action1, args1, kwargs1 = ActionRegistry.suitable_for(
"I do test very well", "en-us", getter=language_getter_mock
)
Action2, args2, kwargs2 = ActionRegistry.suitable_for(
"I do test very bad", "en-us", getter=language_getter_mock
)
assert Action1 is not MyActionSameName
assert Action1 is not Temp2
assert Action1 is Temp1
assert Action2 is Temp2
assert Action2 is MyActionSameName
def test_shared_exon(self):
mocker = Mocker()
self.model = mocker.mock()
self.model.blockStarts
mocker.result([100, 400, 700])
mocker.count(2, None)
self.model.blockSizes
mocker.result([100, 100, 100])
mocker.count(1, None)
self.model.chrom
mocker.result("chr1")
mocker.count(2, None)
self.model.start
mocker.result(0)
mocker.count(1, None)
self.junctions1 = mocker.mock()
self.junctions2 = mocker.mock()
self.junc1 = [400]
self.junc2 = [700]
juncKey = "chr1:200"
self.junctions1[juncKey]
mocker.result(self.junc1)
self.junctions2[juncKey]
mocker.result(self.junc2)
juncKey = "chr1:500"
self.junctions1[juncKey]
mocker.throw(KeyError)
juncKey = "chr1:800"
self.junctions1[juncKey]
mocker.throw(KeyError)
mocker.replay()
self.sharedExons = {}
jc.scanJunctions(self.model, self.junctions1, self.junctions2, self.sharedExons)
for j in self.sharedExons:
self.assertEqual(self.sharedExons[j], [400])
self.assertEqual(j, "chr1:200")
class OAuthTwitterTest(TestCase):
urls = 'django_oauth_twitter.test_urls'
def setUp(self):
self.mocker = Mocker()
self.password = User.objects.create_user('password', '', 'password')
self.twitter = User.objects.create_user('twitter', '', 'twitter')
json = '{"screen_name": "twitter"}'
self.twitter_user = TwitterUser.objects.create(user=self.twitter,
twitter_id=1,
userinfo_json=json)
# Replace TEMPLATE lookups
self.old_template_dirs = settings.TEMPLATE_DIRS
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__),
'templates'), )
self.old_template_loaders = settings.TEMPLATE_LOADERS
settings.TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.load_template_source', )
django.template.loader.template_source_loaders = None
# Replace LOGIN_URL and LOGIN_REDIRECT_URL
self.old_login_url = settings.LOGIN_URL
settings.LOGIN_URL = '/login/'
self.old_login_redirect_url = settings.LOGIN_REDIRECT_URL
settings.LOGIN_REDIRECT_URL = '/home/'
self.old_login_redirect_urlname = getattr(settings,
'LOGIN_REDIRECT_URLNAME',
None)
settings.LOGIN_REDIRECT_URLNAME = None
def tearDown(self):
# Restore TEMPLATE lookups
settings.TEMPLATE_DIRS = self.old_template_dirs
settings.TEMPLATE_LOADERS = self.old_template_loaders
django.template.loader.template_source_loaders = None
# Restore LOGIN_URL and LOGIN_REDIRECT_URL
settings.LOGIN_URL = self.old_login_url
settings.LOGIN_REDIRECT_URL = self.old_login_redirect_url
settings.LOGIN_REDIRECT_URLNAME = self.old_login_redirect_urlname
def test_association_anonymous(self):
import django
# Ensure we need a login.
url = reverse('twitter_associate')
login_url = settings.LOGIN_URL
if django.VERSION < (1, 2):
login_url = self.old_login_url
response = self.client.get(url)
self.assertEqual(
response['Location'], 'http://testserver%s?next=%s' %
(login_url, quote('http://testserver' + url)))
def test_association_user_add(self):
# User adds association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
self.assertTrue(
self.client.login(username=self.password.username,
password=self.password.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{"id": 2}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key},
follow=True)
self.assertEqual(response.redirect_chain,
[('http://testserver/twitter/associate/', 302)])
self.assertEqual(response.status_code, 200)
def test_association_user_remove(self):
# User removes association.
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
self.assertTrue(
self.client.login(username=self.password.username,
password=self.password.username))
response = self.client.post(reverse('twitter_associate'), {
'action': 'remove',
'twitter_id': '1'
})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.password)
def test_association_associated_add(self):
# Associated adds association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api().getRequestToken()
self.mocker.result(TOKEN)
Api(ANY).getAccessToken()
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.id
self.mocker.result('2')
userinfo.AsJsonString()
self.mocker.result('{}')
self.mocker.count(1, 3)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
response = self.client.get(reverse('twitter_signin_associate'))
self.assertEqual(response.status_code, 302)
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': TOKEN.key})
self.assertEqual(
response['Location'], 'http://testserver/twitter/associate/'
'?user=twitter&error=user_already_linked')
def test_association_associated_remove(self):
Api = self.mocker.replace(TwitterApi)
userinfo = self.mocker.mock()
Api(ANY).GetUserInfo()
self.mocker.result(userinfo)
with self.mocker:
# Associated removes association.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
response = self.client.post(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
self.assertTrue(TwitterUser.objects.get(user=self.twitter))
response = self.client.post(reverse('twitter_associate'), {
'action': 'remove',
'twitter_id': '1'
})
self.assertEqual(response.status_code, 200)
self.assertRaises(TwitterUser.DoesNotExist,
TwitterUser.objects.get,
user=self.twitter)
def test_association_user_revoked(self):
# User visits associate after revoking their Twitter credentials.
self.assertTrue(self.twitter.twitter)
self.assertTrue(
self.client.login(username=self.twitter.username,
password=self.twitter.username))
Api = self.mocker.replace(TwitterApi)
Api(ANY).GetUserInfo()
self.mocker.throw(HTTPError('url', 401, '', {}, None))
with self.mocker:
# User goes off to Twitter and gets redirected back to callback
session = self.client.session
session[REQUEST_KEY] = TOKEN.to_string()
session.save()
response = self.client.get(reverse('twitter_associate'))
self.assertEqual(response.status_code, 200)
def test_callback(self):
# User goes directly to the callback page.
response = self.client.get(reverse(oauthtwitter.callback))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User goes directly to the callback page. but tampers with oauth_token
response = self.client.get(reverse(oauthtwitter.callback),
{'oauth_token': 'bad'})
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_URL)
# User comes in through Twitter OAuth, but tampers with oauth_token
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
request.GET
self.mocker.result({'oauth_token': 'bad'})
request.session
self.mocker.result({})
self.mocker.count(1, None)
request.twitter_request_token
self.mocker.result(TOKEN)
# New user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api = self.mocker.replace(TwitterApi)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(AnonymousUser())
userinfo = self.mocker.mock()
cui = self.mocker.replace(cached_user_info)
cui(request, TOKEN)
self.mocker.result(userinfo)
o._authenticate(userinfo=userinfo)
self.mocker.result(None)
# Existing user comes in through Twitter OAuth
request.GET
self.mocker.result({'oauth_token': 'a'})
request.twitter_request_token
self.mocker.result(TOKEN)
Api(TOKEN).getAccessToken()
self.mocker.result(TOKEN)
request.twitter_access_token = ANY
request.user
self.mocker.result(User.objects.get(username='******'))
self.mocker.count(1, 2)
cui(request, TOKEN)
self.mocker.result(userinfo)
self.mocker.count(1, 2)
userinfo.id
self.mocker.result(3)
userinfo.AsJsonString()
self.mocker.result('{}')
with self.mocker:
response = o.callback(request)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o.callback(request)
self.assertEqual(response['Location'],
reverse(oauthtwitter.register))
response = o.callback(request)
self.assertEqual(response['Location'], '/home/')
def test_signin(self):
response = self.client.get(reverse('twitter_signin'))
prefix = 'http://twitter.com/oauth/authenticate?'
self.assertTrue(response['Location'].startswith(prefix),
response['Location'])
def test_register(self):
# User goes directly to the register page.
response = self.client.get(reverse(oauthtwitter.register))
self.assertTrue(response['Location'], settings.LOGIN_URL)
# User is logged in
self.assertTrue(
self.client.login(username='******', password='******'))
response = self.client.get(reverse(oauthtwitter.register))
self.assertEqual(response['Location'],
'http://testserver%s' % settings.LOGIN_REDIRECT_URL)
# New user comes in through Twitter
request = self.mocker.mock()
request.user
self.mocker.result(AnonymousUser())
self.mocker.count(1, None)
RC = self.mocker.replace('django.template.RequestContext')
RC(ANY)
self.mocker.result({})
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.screen_name
self.mocker.result('unknown')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('GET')
# New user posts form through Twitter
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo.id
self.mocker.result(2)
userinfo.screen_name
self.mocker.result('unknown')
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.method
self.mocker.result('POST')
request.POST
self.mocker.result({'username': '******'})
o = self.mocker.patch(oauthtwitter)
o._login_and_redirect(request=request, user=ANY)
self.mocker.result('New user')
with self.mocker:
response = oauthtwitter.register(request)
self.assertEqual(response.status_code, 200)
response = o.register(request)
self.assertEqual(response, 'New user')
self.assertTrue(User.objects.get(username='******'))
def test_authenticate(self):
# Associated Twitter user
twitter = self.mocker.mock()
twitter.id
self.mocker.result(1)
# Unknown Twitter uesr
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
with self.mocker:
self.assertEqual(oauthtwitter._authenticate(twitter),
User.objects.get(username="******"))
self.assertEqual(oauthtwitter._authenticate(unknown), None)
def test_create_user(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
request.user.is_anonymous()
self.mocker.result(False)
o._login_and_redirect(request=request, user=None)
self.mocker.result('Logged in')
# Anonymous user with new User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
unknown = self.mocker.mock()
unknown.id
self.mocker.result(2)
unknown.screen_name
self.mocker.result("unknown")
unknown.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(unknown)
o._login_and_redirect(request=request,
user=MATCH(lambda x: isinstance(x, User)))
self.mocker.result('New user')
# Anonymous user with existing User
request.user.is_anonymous()
self.mocker.result(True)
request.twitter_access_token
self.mocker.result(TOKEN)
twitter = self.mocker.mock()
twitter.screen_name
self.mocker.result("twitter")
request.twitter_userinfo
self.mocker.result(twitter)
with self.mocker:
response = o._create_user(request)
self.assertEqual(response, 'Logged in')
response = o._create_user(request)
self.assertEqual(response, 'New user')
response = o._create_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_login_and_redirect(self):
o = self.mocker.patch(oauthtwitter)
request = self.mocker.mock()
# User already logged in
twitter = User.objects.get(username='******')
request.user
self.mocker.result(twitter)
# No User to log in
True
# Login a Twitter user
o._login(request, twitter)
request.user
self.mocker.result(AnonymousUser())
request.twitter_access_token
self.mocker.result(TOKEN)
userinfo = self.mocker.mock()
userinfo.AsJsonString()
self.mocker.result('{}')
request.twitter_userinfo
self.mocker.result(userinfo)
request.session
self.mocker.result({SUCCESS_URL_KEY: (TOKEN, '/home/')})
request.twitter_request_token
self.mocker.result(TOKEN)
with self.mocker:
response = o._login_and_redirect(request, user=True)
self.assertEqual(response['Location'], settings.LOGIN_REDIRECT_URL)
response = o._login_and_redirect(request, user=None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
response = o._login_and_redirect(request, user=twitter)
self.assertEqual(response['Location'], '/home/')
self.assertEqual(str(twitter.twitter.access_token), str(TOKEN))
self.assertEqual(twitter.twitter.userinfo_json, '{}')
def test_on_new_user(self):
# With auto_create_user
request = self.mocker.mock()
a = self.mocker.patch(OAuthTwitter(auto_create_user=True))
a._create_user(request)
self.mocker.result('auto_create')
# Without
b = self.mocker.patch(oauthtwitter)
with self.mocker:
response = a._on_new_user(request)
self.assertEqual(response, 'auto_create')
response = b._on_new_user(request)
self.assertEqual(response['Location'], '/twitter/register/')
def test_redirect_to_login(self):
response = oauthtwitter._redirect_to_login(None)
self.assertEqual(response['Location'], settings.LOGIN_URL)
class Test_sascalc_Prop_calcpmi(MockerTestCase):
def setUp(self):
self.centertmp = sasop.Move.center
self.m = Mocker()
sasop.Move.center = self.m.mock()
sasop.Move.center(ARGS)
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=sasmol.SasMol(0)
def assert_list_almost_equal_flip_sign_allowed(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
sign=1
for i in range(len(a)):
if isinstance(a[i],(int,float)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
if (a[i]*b[i]<0.0): sign = -1
self.assertAlmostEqual(a[i],sign*b[i],places)
else:
self.assert_list_almost_equal_flip_sign_allowed(a[i],b[i],places)
def reorder_eigens(self, result_eigenvalues, result_eigenvectors):
idx=result_eigenvalues.argsort()
idx=idx[::-1]
result_eigenvalues = result_eigenvalues[idx]
result_eigenvectors = result_eigenvectors[idx]
result_eigenvectors[2]*=-1
return result_eigenvalues, result_eigenvectors
def test_one_atom(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_I), '\n',list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[156.14, 24.022, 36.032], [24.022, 120.108, -72.065], [36.032, -72.065, 60.054]], floattype)
expected_eigenvalues = numpy.array([168.151, 168.151, -5.329e-15], floattype)
expected_eigenvectors = numpy.array([[0.103, -0.812, 0.575], [0.964, 0.148, 0.222], [-0.267, 0.535, 0.802]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_I, result_I, 3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_centered_atoms(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, -2.0, -3.0],[1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[26., -4., -6.], [-4., 20., -12.], [-6., -12., 10.]], floattype)
expected_eigenvalues = numpy.array([336.302, 336.302, -7.105e-15], floattype)
expected_eigenvectors = numpy.array([[-0.103, -0.812, 0.575], [0.964, -0.148, -0.222], [0.267, 0.535, 0.802]],floattype)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_uncentered_atoms(self):
self.o.setCoor(numpy.array([[[-2.0, -2.0, -3.0],[1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','N'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print result_I, '\n', result_eigenvalues, '\n',result_eigenvectors
expected_eigenvalues = numpy.array([400.277, 394.737, 5.54], floattype)
expected_eigenvectors = numpy.array([[-6.274e-15, -8.321e-01, 5.547e-01], [9.246e-01, -2.114e-01, -3.170e-01], [3.810e-01, 5.129e-01, 7.693e-01]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
def test_six_uncentered_atoms(self):
self.o.setCoor(numpy.array([[[1.0, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','N','O','C','N','O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print result_I, '\n',result_eigenvalues, '\n', result_eigenvectors
expected_eigenvalues = numpy.array([5761.418, 5625.53, 139.66], floattype)
expected_eigenvectors = numpy.array([[0.351, -0.821, 0.451], [-0.837, -0.059, 0.544],[0.42, 0.568, 0.708]],floattype);
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,2)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
def test_six_uncentered_atoms_inf1(self):
self.o.setCoor(numpy.array([[[util.HUGE, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_inf2(self):
self.o.setCoor(numpy.array([[[util.INF, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_nan(self):
self.o.setCoor(numpy.array([[[util.NAN, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_tiny(self):
self.o.setCoor(numpy.array([[[util.TINY, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','N','O','C','N','O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_I), '\n', list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[4675.176, -1324.189, -1572.26 ], [-1324.189, 3932.916, -2256.545], [-1572.26 , -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447], floattype)
expected_eigenvectors = numpy.array([[0.321, -0.821, 0.472], [-0.852, -0.032, 0.523], [0.414, 0.57, 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,2)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
def test_six_uncentered_atoms_ZERO(self):
self.o.setCoor(numpy.array([[[util.ZERO, 2.0, 3.0],[4.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','N','O','C','N','O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_I), '\n',list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[4675.176, -1324.189, -1572.26 ], [-1324.189, 3932.916, -2256.545], [-1572.26 , -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447], floattype)
expected_eigenvectors = numpy.array([[ 0.321, -0.821, 0.472], [-0.852, -0.032, 0.523], [ 0.414, 0.57 , 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,2)
self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
def tearDown(self):
self.m.restore()
self.m.verify()
sasop.Move.center = self.centertmp
class AccountGroupTests(TestCase):
fixtures = ["customer_tests.json"]
username = "******"
password = "******"
def setUp(self):
self.mocker = Mocker()
def tearDown(self):
self.mocker.restore()
def test_process_from_queue_without_messages(self):
account = Account.objects.get(name="AccessWithPurchase")
ag = AccountGroup(account)
retcode = ag.process_from_queue()
self.assertEqual(retcode, False)
def test_process_from_queue_with_messages(self):
ev = threading.Event()
mock_Event = self.mocker.replace(ev)
mock_Event()
self.mocker.result(mock_Event)
self.mocker.count(0, 10)
mock_Event.set()
self.mocker.result(True)
self.mocker.count(0, 10)
mock_Queue = self.mocker.replace("Queue")
mock_Queue()
self.mocker.result(True)
self.mocker.count(0, 3)
self.mocker.replay()
ms = MessageScheduler({})
processor = SMSProcessor()
for i in range(0, 10):
processor.sendSMS(
AccountGroupTests.username,
AccountGroupTests.password,
"AccessWithPurchase",
"foo",
"bar",
datetime.datetime.now(),
)
account = Account.objects.get(name="AccessWithPurchase")
ag = AccountGroup(account)
ms.account_groups[account.id] = ag
ms.enqueue_messages()
retcode = ag.process_from_queue()
self.assertEqual(retcode, True)
self.assertEqual(ag.work.qsize(), 10)
self.fail("Este test no funciona, hay que rehacerlo")
self.mocker.verify()
def test_create_accountThreads(self):
dummy_AccountThread = self.mocker.replace("singularmsd.AccountThread")
dummy_AccountThread(ANY, ANY)
self.mocker.result(dummy_AccountThread)
self.mocker.count(4)
dummy_AccountThread.num_threads
self.mocker.result(4)
self.mocker.count(4)
dummy_AccountThread.start()
self.mocker.result(True)
self.mocker.count(4)
self.mocker.replay()
account = Account.objects.get(name="AccessWithPurchase")
ag = AccountGroup(account)
ag.create_accountThreads()
self.assertEqual(len(ag.threads), 4)
self.mocker.verify()
def test_parsing_files_with_many_scenarios_returns_parsed_scenarios():
mocker = Mocker()
class DoSomethingAction:
def execute(context, *args, **kwargs):
pass
class DoSomethingElseAction:
def execute(context, *args, **kwargs):
pass
class DoYetAnotherThingAction:
def execute(context, *args, **kwargs):
pass
settings = Settings()
files = ["some path"]
story_text = """As a someone
I want to do something
So that I'm happy
Scenario 1 - Test Scenario
Given
I do something
When
I do something else
Then
I do yet another thing
Scenario 2 - Test Scenario
Given
I do something
When
#some custom comment
Then
I do yet another thing"""
filemock = mocker.mock()
filemock.list_files(directories=settings.tests_dirs,
pattern=settings.file_pattern)
mocker.result(files)
filemock.read_file(files[0])
mocker.result(story_text)
language_mock = mocker.mock()
language_mock.get("as_a")
mocker.result("As a")
language_mock.get("i_want_to")
mocker.result("I want to")
language_mock.get("so_that")
mocker.result("So that")
language_mock.get("given")
mocker.result("Given")
mocker.count(min=1, max=None)
language_mock.get("when")
mocker.result("When")
mocker.count(min=1, max=None)
language_mock.get("then")
mocker.result("Then")
mocker.count(min=1, max=None)
language_mock.get("scenario")
mocker.result("Scenario")
mocker.count(min=1, max=None)
action_registry_mock = mocker.mock()
action_registry_mock.suitable_for("I do something", 'en-us')
mocker.result((DoSomethingAction, [], {}))
mocker.count(min=1, max=None)
action_registry_mock.suitable_for("I do something else", 'en-us')
mocker.result((DoSomethingElseAction, [], {}))
mocker.count(min=1, max=None)
action_registry_mock.suitable_for("I do yet another thing", 'en-us')
mocker.result((DoYetAnotherThingAction, [], {}))
mocker.count(min=1, max=None)
with mocker:
parser = FileParser(language=language_mock,
file_object=filemock,
action_registry=action_registry_mock)
fixture = parser.get_stories(settings=settings)
assert_no_invalid_stories(fixture)
assert len(fixture.stories) == 1, "Expected 1, Actual: %d" % len(
fixture.stories)
assert len(fixture.stories[0].scenarios) == 2
assert fixture.stories[0].scenarios[1].whens[
0].description == "#some custom comment"
class Test_unit_sasop_Move_center(MockerTestCase):
def setUp(self):
self.m = Mocker()
self.back_masscheck = sasop.Move.masscheck
sasop.Move.masscheck = self.m.mock()
sasop.Move.masscheck(ARGS)
self.m.result(None)
self.m.count(0,None)
self.back_calccom = sascalc.Prop.calccom
sascalc.Prop.calccom = self.m.mock()
sascalc.Prop.calccom(ARGS)
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=sasmol.SasMol(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
self.o.setCom(numpy.array([-1.0, 2.0, 3.0],floattype))
self.o.center(0)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[0.0, 0.0, 0.0]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
self.o.setCom(numpy.array([-3.0, 2.6, 4.935],floattype))
self.o.center(0)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[2.0, -0.6, -1.065],[-2.0, 0.6, 1.065]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, 5.333],floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf1(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.HUGE],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, util.HUGE], floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf2(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.INF],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, util.INF],floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_nan(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.NAN],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, util.NAN],floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_tiny(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.TINY],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, 4.833],floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_zero(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.ZERO],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
print numpy.average(self.o.coor()[0],axis=0)
self.o.setCom(numpy.array([1.533, 4.0, 4.833],floattype))
expected_coor = self.o.coor()[0]-self.o.com()
self.o.center(0)
result_coor = self.o.coor()[0]
print result_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
sascalc.Prop.calccom =self.back_calccom
sasop.Move.masscheck =self.back_masscheck
class TestBuildJunctionDict(TestCase):
def setUp(self):
self.mocker = Mocker()
self.junctions = self.mocker.mock()
self.junction1 = self.mocker.mock()
self.junction2 = self.mocker.mock()
self.junction3 = self.mocker.mock()
self.junction1.start
self.mocker.result(100)
self.mocker.count(0, None)
self.junction1.end
self.mocker.result(200)
self.mocker.count(0, None)
self.junction1.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
self.junction2.start
self.mocker.result(100)
self.mocker.count(0, None)
self.junction2.end
self.mocker.result(300)
self.mocker.count(0, None)
self.junction2.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
self.junction3.start
self.mocker.result(200)
self.mocker.count(0, None)
self.junction3.end
self.mocker.result(300)
self.mocker.count(0, None)
self.junction3.chrom
self.mocker.result('chr1')
self.mocker.count(0, None)
def test_no_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1)])
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200])
self.assertEqual(len(self.container), 1)
self.mocker.restore()
self.mocker.verify()
def test_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1),
('chr1:100-300', self.junction2)])
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200, 300])
self.assertEqual(len(self.container), 1)
self.mocker.restore()
self.mocker.verify()
def test_multiple_junctions_with_overlaps(self):
self.junctions.iteritems()
self.mocker.generate([('chr1:100-200', self.junction1),
('chr1:100-300', self.junction2),
('chr1:200-300', self.junction3)], )
self.mocker.replay()
self.container = jc.buildJunctionDict(self.junctions)
self.assertEqual(self.container['chr1:100'], [200, 300])
self.assertEqual(self.container['chr1:200'], [300])
self.assertEqual(len(self.container), 2)
self.mocker.restore()
self.mocker.verify()
def test_parsing_files_with_many_scenarios_returns_parsed_scenarios():
mocker = Mocker()
class DoSomethingAction:
def execute(context, *args, **kwargs):
pass
class DoSomethingElseAction:
def execute(context, *args, **kwargs):
pass
class DoYetAnotherThingAction:
def execute(context, *args, **kwargs):
pass
settings = Settings()
files = ["some path"]
story_text = """As a someone
I want to do something
So that I'm happy
Scenario 1 - Test Scenario
Given
I do something
When
I do something else
Then
I do yet another thing
Scenario 2 - Test Scenario
Given
I do something
When
#some custom comment
Then
I do yet another thing"""
filemock = mocker.mock()
filemock.list_files(directories=settings.tests_dirs, pattern=settings.file_pattern)
mocker.result(files)
filemock.read_file(files[0])
mocker.result(story_text)
language_mock = mocker.mock()
language_mock.get("as_a")
mocker.result("As a")
language_mock.get("i_want_to")
mocker.result("I want to")
language_mock.get("so_that")
mocker.result("So that")
language_mock.get("given")
mocker.result("Given")
mocker.count(min=1, max=None)
language_mock.get("when")
mocker.result("When")
mocker.count(min=1, max=None)
language_mock.get("then")
mocker.result("Then")
mocker.count(min=1, max=None)
language_mock.get("scenario")
mocker.result("Scenario")
mocker.count(min=1, max=None)
action_registry_mock = mocker.mock()
action_registry_mock.suitable_for("I do something", 'en-us')
mocker.result((DoSomethingAction, [], {}))
mocker.count(min=1, max=None)
action_registry_mock.suitable_for("I do something else", 'en-us')
mocker.result((DoSomethingElseAction, [], {}))
mocker.count(min=1, max=None)
action_registry_mock.suitable_for("I do yet another thing", 'en-us')
mocker.result((DoYetAnotherThingAction, [], {}))
mocker.count(min=1, max=None)
with mocker:
parser = FileParser(language=language_mock, file_object=filemock, action_registry=action_registry_mock)
fixture = parser.get_stories(settings=settings)
assert_no_invalid_stories(fixture)
assert len(fixture.stories) == 1, "Expected 1, Actual: %d" % len(fixture.stories)
assert len(fixture.stories[0].scenarios) == 2
assert "#some custom comment" in fixture.stories[0].scenarios[1].whens[0].description, "Expected \"#some custom comment\", Actual: \"%s\"" % fixture.stories[0].scenarios[1].whens[0].description
def setUpZope(self, app, configurationContext):
from mocker import Mocker
from mocker import ANY
from mocker import KWARGS
mocker = Mocker()
postmonkey = mocker.replace("postmonkey")
mailchimp = postmonkey.PostMonkey(ANY)
mocker.count(0, 1000)
# Lists
mailchimp.lists()
mocker.count(0, 1000)
mocker.result({
u'total':
2,
u'data': [
{
u'id': id_generator(),
u'web_id': 625,
u'name': u'ACME Newsletter',
u'default_from_name': u'*****@*****.**',
},
{
u'id': id_generator(),
u'web_id': 626,
u'name': u'ACME Newsletter 2',
u'default_from_name': u'*****@*****.**',
},
]
})
# Ping
mailchimp.ping()
mocker.count(0, 1000)
mocker.result(True)
# Templates
mailchimp.templates()
mocker.count(0, 1000)
mocker.result({
'user': [{
u'id': 1,
u'name': u'My template',
u'layout': u'basic',
u'preview_image': u'http://nohost/preview.jpg',
u'date_created': u'2013/01/01',
u'edit_source': True,
}, {
u'id': 2,
u'name': u'My template 2',
u'layout': u'advanced',
u'preview_image': u'http://nohost/preview.jpg',
u'date_created': u'2012/01/01',
u'edit_source': False
}]
})
# Campaigns
mailchimp.campaignCreate(KWARGS)
mocker.count(0, 1000)
mocker.result(123)
mailchimp.campaigns(KWARGS)
mocker.count(0, 1000)
mocker.result({'data': [{'web_id': '123QWE456'}]})
# Get account details
mailchimp.getAccountDetails()
mocker.count(0, 1000)
mocker.result({
u'total':
1,
u'data': [{
u'use_awesomebar': True,
u'beamer_address': u'[email protected]',
u'web_id': 17241,
u'name': u'Test Newsletter',
u'email_type_option': False,
u'modules': [],
u'default_language': u'de',
u'default_from_name': u'Timo Stollenwerk',
u'visibility': u'pub',
u'subscribe_url_long':
u'http://johndoe.us4.list-manage1.com/subscribe?u=5e&id=fd',
u'default_subject': u'Test Newsletter',
u'subscribe_url_short': u'http://eepurl.com/h6Rjg',
u'default_from_email': u'*****@*****.**',
u'date_created': u'2011-12-27 16:15:03',
u'list_rating': 0,
u'id': u'f6257645gs',
u'stats': {
u'grouping_count': 0,
u'open_rate': None,
u'member_count': 0,
u'click_rate': None,
u'cleaned_count_since_send': 0,
u'member_count_since_send': 0,
u'target_sub_rate': None,
u'group_count': 0,
u'avg_unsub_rate': None,
u'merge_var_count': 2,
u'unsubscribe_count': 0,
u'cleaned_count': 0,
u'avg_sub_rate': None,
u'unsubscribe_count_since_send': 0,
u'campaign_count': 1
}
}]
})
mocker.replay()
# Load ZCML
import redturtle.monkey
self.loadZCML(package=redturtle.monkey)
z2.installProduct(app, 'redturtle.monkey')
def setUpZope(self, app, configurationContext):
from mocker import Mocker
from mocker import ANY
from mocker import KWARGS
mocker = Mocker()
postmonkey = mocker.replace("postmonkey")
mailchimp = postmonkey.PostMonkey(ANY)
mocker.count(0, 1000)
# Lists
mailchimp.lists()
mocker.count(0, 1000)
mocker.result({
u'total':
2,
u'data': [
{
u'id': u'f6257645gs',
u'web_id': 625,
u'name': u'ACME Newsletter',
u'default_from_name': u'*****@*****.**',
},
{
u'id': u'f6267645gs',
u'web_id': 626,
u'name': u'ACME Newsletter 2',
u'default_from_name': u'*****@*****.**',
},
]
})
# List Interest Groupings
mailchimp.listInterestGroupings(KWARGS)
mocker.count(0, 1000)
mocker.result([{
u'groups': [{
u'bit': u'1',
u'display_order': u'1',
u'name': u'Interest Group 1',
u'subscribers': 0
}, {
u'bit': u'2',
u'display_order': u'2',
u'name': u'Interest Group 2',
u'subscribers': 0
}, {
u'bit': u'3',
u'display_order': u'3',
u'name': u'Interest Group 3',
u'subscribers': 1
}]
}])
# Get account details
mailchimp.getAccountDetails()
mocker.count(0, 1000)
mocker.result([])
result = { # noqa
u'total':
1,
u'data': [{
u'use_awesomebar': True,
u'beamer_address': u'[email protected]',
u'web_id': 17241,
u'name': u'Test Newsletter',
u'email_type_option': False,
u'modules': [],
u'default_language': u'de',
u'default_from_name': u'Timo Stollenwerk',
u'visibility': u'pub',
u'subscribe_url_long':
u'http://johndoe.us4.list-manage1.com/subscribe?u=5e&id=fd', # noqa
u'default_subject': u'Test Newsletter',
u'subscribe_url_short': u'http://eepurl.com/h6Rjg',
u'default_from_email': u'*****@*****.**',
u'date_created': u'2011-12-27 16:15:03',
u'list_rating': 0,
u'id': u'f6257645gs',
u'stats': {
u'grouping_count': 0,
u'open_rate': None,
u'member_count': 0,
u'click_rate': None,
u'cleaned_count_since_send': 0,
u'member_count_since_send': 0,
u'target_sub_rate': None,
u'group_count': 0,
u'avg_unsub_rate': None,
u'merge_var_count': 2,
u'unsubscribe_count': 0,
u'cleaned_count': 0,
u'avg_sub_rate': None,
u'unsubscribe_count_since_send': 0,
u'campaign_count': 1
}
}]
}
mocker.replay()
# Load ZCML
import collective.mailchimp
xmlconfig.file('configure.zcml',
collective.mailchimp,
context=configurationContext)
class Test_unit_operate_Move_translate_to_point(MockerTestCase):
def setUp(self):
self.back_mass_check = operate.Move.mass_check
self.back_calccom = calculate.Calculate.calculate_center_of_mass
self.m = Mocker()
operate.Move.mass_check = self.m.mock()
operate.Move.mass_check()
self.m.result(None)
self.m.count(0,None)
calculate.Calculate.calculate_center_of_mass = self.m.mock()
calculate.Calculate.calculate_center_of_mass(ARGS)
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=system.Molecule(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
self.o.setCom(numpy.array([-1.0, 2.0, 3.0],floattype))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[1.0, 3.0, 6.0]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor
expected_coor = numpy.array([[3.0, 2.4, 4.935],[-1.0, 3.6, 7.065]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms(self):
coorback = numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf1(self):
coorback = numpy.array([[[1.2, 2.0, util.HUGE],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, util.HUGE],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf2(self):
coorback = numpy.array([[[1.2, 2.0, util.INF],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, util.INF],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_nan(self):
coorback = numpy.array([[[1.2, 2.0, util.NAN],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, util.NAN],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_tiny(self):
coorback = numpy.array([[[1.2, 2.0, util.TINY],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, util.TINY],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_zero(self):
coorback = numpy.array([[[1.2, 2.0, util.ZERO],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
coor = numpy.array([[[1.2, 2.0, util.ZERO],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype)
self.o.setCoor(coor)
self.o.setCom(numpy.average(self.o.coor()[0],axis=0))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value,point=True)
result_coor = self.o.coor()[0]
print result_coor,'\n\n'
expected_coor = coorback[0]-self.o.com()+value
print expected_coor
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
calculate.Calculate.calculate_center_of_mass =self.back_calccom
operate.Move.mass_check =self.back_mass_check
class Test_sascalc_Prop_calcpmi(MockerTestCase):
def setUp(self):
self.centertmp = sasop.Move.center
self.m = Mocker()
sasop.Move.center = self.m.mock()
sasop.Move.center(ARGS)
self.m.result(None)
self.m.count(0, None)
self.m.replay()
self.o = sasmol.SasMol(0)
def assert_list_almost_equal_flip_sign_allowed(self, a, b, places=5):
if (len(a) != len(b)):
raise TypeError
else:
sign = 1
for i in range(len(a)):
if isinstance(a[i], (int, float)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
if (a[i] * b[i] < 0.0): sign = -1
self.assertAlmostEqual(a[i], sign * b[i], places)
else:
self.assert_list_almost_equal_flip_sign_allowed(
a[i], b[i], places)
def reorder_eigens(self, result_eigenvalues, result_eigenvectors):
idx = result_eigenvalues.argsort()
idx = idx[::-1]
result_eigenvalues = result_eigenvalues[idx]
result_eigenvectors = result_eigenvectors[idx]
result_eigenvectors[2] *= -1
return result_eigenvalues, result_eigenvectors
def test_one_atom(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_I), '\n',list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[156.14, 24.022, 36.032], [24.022, 120.108, -72.065], [36.032, -72.065, 60.054]], floattype)
expected_eigenvalues = numpy.array([168.151, 168.151, -5.329e-15], floattype)
expected_eigenvectors = numpy.array([[0.103, -0.812, 0.575], [0.964, 0.148, 0.222], [-0.267, 0.535, 0.802]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(expected_I, result_I, 3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_centered_atoms(self):
return
'''
self.o.setCoor(numpy.array([[[-1.0, -2.0, -3.0],[1.0, 2.0, 3.0]]],floattype))
self.o.setElement(['C','C'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(result_eigenvalues, result_eigenvectors)
print list(result_eigenvalues), '\n', list(result_eigenvectors)
expected_I = numpy.array([[26., -4., -6.], [-4., 20., -12.], [-6., -12., 10.]], floattype)
expected_eigenvalues = numpy.array([336.302, 336.302, -7.105e-15], floattype)
expected_eigenvectors = numpy.array([[-0.103, -0.812, 0.575], [0.964, -0.148, -0.222], [0.267, 0.535, 0.802]],floattype)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvalues, result_eigenvalues,3)
#self.assert_list_almost_equal_flip_sign_allowed(expected_eigenvectors, result_eigenvectors,3)
'''
def test_two_uncentered_atoms(self):
self.o.setCoor(
numpy.array([[[-2.0, -2.0, -3.0], [1.0, 2.0, 3.0]]], floattype))
self.o.setElement(['C', 'N'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print result_I, '\n', result_eigenvalues, '\n', result_eigenvectors
expected_eigenvalues = numpy.array([400.277, 394.737, 5.54], floattype)
expected_eigenvectors = numpy.array(
[[-6.274e-15, -8.321e-01, 5.547e-01],
[9.246e-01, -2.114e-01, -3.170e-01],
[3.810e-01, 5.129e-01, 7.693e-01]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms(self):
self.o.setCoor(
numpy.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print result_I, '\n', result_eigenvalues, '\n', result_eigenvectors
expected_eigenvalues = numpy.array([5761.418, 5625.53, 139.66],
floattype)
expected_eigenvectors = numpy.array(
[[0.351, -0.821, 0.451], [-0.837, -0.059, 0.544],
[0.42, 0.568, 0.708]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms_inf1(self):
self.o.setCoor(
numpy.array(
[[[util.HUGE, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_inf2(self):
self.o.setCoor(
numpy.array(
[[[util.INF, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_nan(self):
self.o.setCoor(
numpy.array(
[[[util.NAN, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setMass([1.0, 2.0, 3.2, 3.6, 5.2, 2.8])
self.o.setNatoms(len(self.o.mass()))
with self.assertRaises(Exception):
result = self.o.calcpmi(0)
def test_six_uncentered_atoms_tiny(self):
self.o.setCoor(
numpy.array(
[[[util.TINY, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print list(result_I), '\n', list(result_eigenvalues), '\n', list(
result_eigenvectors)
expected_I = numpy.array(
[[4675.176, -1324.189, -1572.26], [-1324.189, 3932.916, -2256.545],
[-1572.26, -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447],
floattype)
expected_eigenvectors = numpy.array(
[[0.321, -0.821, 0.472], [-0.852, -0.032, 0.523],
[0.414, 0.57, 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def test_six_uncentered_atoms_ZERO(self):
self.o.setCoor(
numpy.array(
[[[util.ZERO, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0],
[1.0, 3.0, 5.0], [2.0, 4.0, 6.0], [0.0, 2.0, 3.0]]],
floattype))
self.o.setElement(['C', 'N', 'O', 'C', 'N', 'O'])
self.o.setNatoms(len(self.o.element()))
result = self.o.calcpmi(0)
result_eigenvalues = result[0]
result_eigenvectors = result[1].T
result_I = result[2]
result_eigenvalues, result_eigenvectors = self.reorder_eigens(
result_eigenvalues, result_eigenvectors)
print list(result_I), '\n', list(result_eigenvalues), '\n', list(
result_eigenvectors)
expected_I = numpy.array(
[[4675.176, -1324.189, -1572.26], [-1324.189, 3932.916, -2256.545],
[-1572.26, -2256.545, 2894.494]], floattype)
expected_eigenvalues = numpy.array([5748.699, 5591.441, 162.447],
floattype)
expected_eigenvectors = numpy.array(
[[0.321, -0.821, 0.472], [-0.852, -0.032, 0.523],
[0.414, 0.57, 0.709]], floattype)
self.assert_list_almost_equal_flip_sign_allowed(
expected_I, result_I, 3)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvalues, result_eigenvalues, 2)
self.assert_list_almost_equal_flip_sign_allowed(
expected_eigenvectors, result_eigenvectors, 3)
def tearDown(self):
self.m.restore()
self.m.verify()
sasop.Move.center = self.centertmp
class TestIdentifyJunctions(TestCase):
def setUp(self):
self.mocker = Mocker()
self.exon1 = self.mocker.mock()
self.exon2 = self.mocker.mock()
self.exon3 = self.mocker.mock()
self.exon4 = self.mocker.mock()
self.exon5 = self.mocker.mock()
self.exon6 = self.mocker.mock()
self.exon7 = self.mocker.mock()
self.exon8 = self.mocker.mock()
self.exon9 = self.mocker.mock()
self.exon10 = self.mocker.mock()
self.exon1.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon1.start
self.mocker.result(1100)
self.mocker.count(1, None)
self.exon1.end
self.mocker.result(1200)
self.mocker.count(1, None)
self.exon1.prevExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon1.nextExons
self.mocker.result([
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1500-1600',
])
self.mocker.count(1, None)
self.exon2.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon2.start
self.mocker.result(1300)
self.mocker.count(1, None)
self.exon2.end
self.mocker.result(1400)
self.mocker.count(1, None)
self.exon2.nextExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon2.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon3.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon3.start
self.mocker.result(1250)
self.mocker.count(1, None)
self.exon3.end
self.mocker.result(1400)
self.mocker.count(1, None)
self.exon3.nextExons
self.mocker.result(set(['chr1:1500-1600', 'chr1:1900-2000']))
self.mocker.count(1, None)
self.exon3.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon4.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon4.start
self.mocker.result(1300)
self.mocker.count(1, None)
self.exon4.end
self.mocker.result(1350)
self.mocker.count(1, None)
self.exon4.nextExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon4.prevExons
self.mocker.result(set(['chr1:1100-1200']))
self.mocker.count(1, None)
self.exon5.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon5.start
self.mocker.result(1500)
self.mocker.count(1, None)
self.exon5.end
self.mocker.result(1600)
self.mocker.count(1, None)
self.exon5.nextExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.exon5.prevExons
self.mocker.result(
set([
'chr1:1100-1200',
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1220-1320',
]))
self.mocker.count(1, None)
self.exon6.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon6.start
self.mocker.result(1700)
self.mocker.count(1, None)
self.exon6.end
self.mocker.result(1800)
self.mocker.count(1, None)
self.exon6.nextExons
self.mocker.result(set(['chr1:1900-2000', 'chr1:1930-2300']))
self.mocker.count(1, None)
self.exon6.prevExons
self.mocker.result(set(['chr1:1500-1600']))
self.mocker.count(1, None)
self.exon7.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon7.start
self.mocker.result(1900)
self.mocker.count(1, None)
self.exon7.end
self.mocker.result(2000)
self.mocker.count(1, None)
self.exon7.nextExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon7.prevExons
self.mocker.result(set(['chr1:1250-1400', 'chr1:1700-1800']))
self.mocker.count(1, None)
self.exon8.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon8.start
self.mocker.result(1220)
self.mocker.count(1, None)
self.exon8.end
self.mocker.result(1320)
self.mocker.count(1, None)
self.exon8.nextExons
self.mocker.result(['chr1:1500-1600'])
self.mocker.count(1, None)
self.exon8.prevExons
self.mocker.result(set([]))
self.mocker.count(1, None)
self.exon9.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon9.start
self.mocker.result(1900)
self.mocker.count(1, None)
self.exon9.end
self.mocker.result(2300)
self.mocker.count(1, None)
self.exon9.nextExons
self.mocker.result([])
self.mocker.count(1, None)
self.exon9.prevExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.exon10.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.exon10.start
self.mocker.result(1930)
self.mocker.count(1, None)
self.exon10.end
self.mocker.result(2300)
self.mocker.count(1, None)
self.exon10.nextExons
self.mocker.result([])
self.mocker.count(1, None)
self.exon10.prevExons
self.mocker.result(set(['chr1:1700-1800']))
self.mocker.count(1, None)
self.mocker.replay()
def test_alternative_splice_site(self):
self.genes = {
'chr1:gene1': [
'chr1:1100-1200',
'chr1:1300-1400',
'chr1:1250-1400',
'chr1:1300-1350',
'chr1:1500-1600',
'chr1:1700-1800',
'chr1:1900-2000',
'chr1:1220-1320',
'chr1:1900-2300',
'chr1:1930-2300',
]
}
self.exons = {}
self.exons['chr1:1100-1200'] = self.exon1
self.exons['chr1:1300-1400'] = self.exon2
self.exons['chr1:1250-1400'] = self.exon3
self.exons['chr1:1300-1350'] = self.exon4
self.exons['chr1:1500-1600'] = self.exon5
self.exons['chr1:1700-1800'] = self.exon6
self.exons['chr1:1900-2000'] = self.exon7
self.exons['chr1:1220-1320'] = self.exon8
self.exons['chr1:1900-2300'] = self.exon9
self.exons['chr1:1930-2300'] = self.exon10
self.junctions = jc.identifyJunctions(self.genes, self.exons)
self.assertEqual(len(self.junctions), 10)
altSplicing = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'alternativeSplicing']
print >> sys.stderr, 'alter splicing', altSplicing
altSS = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'alternativeSpliceSite']
#print >> sys.stderr, 'alter splice site', altSS
skipped = [k for k in self.junctions.keys() \
if self.junctions[k].event == 'skippedExon']
#print >> sys.stderr, 'skipped exon', skipped
noAlt = [
k for k in self.junctions.keys() if not self.junctions[k].event
]
self.assertEqual(len(altSplicing), 2)
self.assertEqual(len(altSS), 4)
self.assertEqual('chr1:1200-1300' in altSS, True)
self.assertEqual(len(skipped), 2)
self.assertEqual('chr1:1200-1500' in skipped, True)
self.assertEqual(len(noAlt), 2)
class TestCreatePath(TestCase):
def setUp(self):
self.mocker = Mocker()
self.isoform1 = self.mocker.mock()
self.isoform2 = self.mocker.mock()
self.isoform3 = self.mocker.mock()
self.isoform1.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform1.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform1.end
self.mocker.result(2000)
self.isoform1.name
self.mocker.result('chr1:gene1.1')
self.isoform1.startCodon
self.mocker.result(1000)
self.isoform1.stopCodon
self.mocker.result(2000)
self.isoform1.blockSizes
self.mocker.result([100, 100, 100, 100, 100])
self.mocker.count(1, None)
self.isoform1.blockStarts
self.mocker.result([100, 300, 500, 700, 900])
self.mocker.count(1, None)
self.isoform2.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform2.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform2.end
self.mocker.result(2000)
self.isoform2.name
self.mocker.result('chr1:gene1.2')
self.isoform2.startCodon
self.mocker.result(1000)
self.isoform2.stopCodon
self.mocker.result(2000)
self.isoform2.blockSizes
self.mocker.result([100, 150, 100, 100, 100])
self.mocker.count(1, None)
self.isoform2.blockStarts
self.mocker.result([100, 250, 500, 700, 900])
self.mocker.count(1, None)
self.isoform3.chrom
self.mocker.result('chr1')
self.mocker.count(1, None)
self.isoform3.chromStart
self.mocker.result(1000)
self.mocker.count(1, None)
self.isoform3.end
self.mocker.result(2000)
self.isoform3.name
self.mocker.result('chr1:gene1.3')
self.isoform3.startCodon
self.mocker.result(1000)
self.isoform3.stopCodon
self.mocker.result(2000)
self.isoform3.blockSizes
self.mocker.result([100, 50, 100, 100, 100])
self.mocker.count(1, None)
self.isoform3.blockStarts
self.mocker.result([100, 300, 500, 700, 900])
self.mocker.count(1, None)
self.mocker.replay()
def test_grouping(self):
self.group = {}
self.exons = {}
jc.groupExons(self.group, self.exons, self.isoform1)
jc.groupExons(self.group, self.exons, self.isoform2)
jc.groupExons(self.group, self.exons, self.isoform3)
self.assertEqual(len(self.group), 1)
self.assertEqual(self.group.keys()[0], 'chr1:gene1')
self.assertEqual(len(self.exons), 7)
self.assertEqual(len(self.exons['chr1:1100-1200'].nextExons), 3)
self.assertEqual(len(self.exons['chr1:1100-1200'].prevExons), 0)
self.assertEqual(len(self.exons['chr1:1500-1600'].prevExons), 3)
self.assertEqual(len(self.exons['chr1:1700-1800'].prevExons), 1)
self.assertEqual(len(self.exons['chr1:1900-2000'].nextExons), 0)
class Test_unit_operate_Move_translate(MockerTestCase):
def setUp(self):
self.m = Mocker()
self.back_mass_check = operate.Move.mass_check
operate.Move.mass_check = self.m.mock()
operate.Move.mass_check()
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=system.Molecule(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom_about_X_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[1.0, -1.0, 1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_one_atom_about_Y_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'y'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[1.0, 1.0, -1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_one_atom_about_Z_axis(self):
'''
test one atom rotating about the z axis
'''
self.o.setCoor(numpy.array([[[1.0, 1.0, 1.0]]],floattype))
axis = 'z'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[-1.0, 1.0, 1.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_X_axis(self):
'''
test two atoms rotating about the x axis
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[-1.0, -3.87, 2.0],[-5.0, -6.0, 3.2]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_Y_axis(self):
#test two atoms rotating about the x axis
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'y'
theta = util.num_to_floattype(90.0*numpy.pi/180.0, floattype)
frame = 0
#
expected_coor = numpy.array([[[3.87, 2.0, 1.0],[6.0, 3.2, 5.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms_about_Z_axis(self):
'''
test two atoms rotating about the x axis
'''
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
axis = 'z'
theta = util.num_to_floattype(280.0*numpy.pi/180.0, floattype)
frame = 0
#
#expected_coor = numpy.array([[[-2.0, -1.0, 3.87],[-3.2, -5.0, 6.0]]], floattype)[frame]
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[-1.0*cs-2.0*si, -1.0*si+2.0*cs, 3.87],[-5.0*cs-3.2*si, -5.0*si+3.2*cs, 6.0]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_inf1(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.HUGE*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
#the first element becomes nan after 1.2+inf*0(nan)
def test_six_atoms_about_X_axis_inf2(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.INF*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, 2.0*cs-3.0*si, 2.0*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
#the first row of elements becomes all nan due to operation between the regular number with nan*0
def test_six_atoms_about_X_axis_nan(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(util.NAN*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.NAN*cs-3.0*si, util.NAN*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_tiny(self):
self.o.setCoor(numpy.array([[[1.2, util.TINY, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.TINY*cs-3.0*si, util.TINY*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_about_X_axis_zero(self):
self.o.setCoor(numpy.array([[[1.2, util.ZERO, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
axis = 'x'
theta = util.num_to_floattype(128.0*numpy.pi/180.0, floattype)
frame = 0
#
cs=numpy.cos(theta)
si=numpy.sin(theta)
expected_coor = numpy.array([[[1.2, util.ZERO*cs-3.0*si, util.ZERO*si+3.0*cs],[-2.0, 5.0*cs-6.0*si, 5.0*si+6.0*cs],[7.0, 8.0*cs-9.0*si, 8.0*si+9.0*cs],[1.0, 3.0*cs-5.0*si, 3.0*si+5.0*cs],[2.0, 4.0*cs-6.0*si, 4.0*si+6.0*cs],[0.0, 2.0*cs-3.0*si, 2.0*si+3.0*cs]]],floattype)[frame]
print 'expected_coor:\n', expected_coor
#
self.o.rotate(frame,axis,theta)
result_coor = self.o.coor()[frame]
print 'result_coor:\n',result_coor
#
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
operate.Move.mass_check =self.back_mass_check
class MessageSchedulerTests (TestCase):
fixtures = ['customer_tests.json', ]
def setUp(self):
self.mocker = Mocker()
def tearDown(self):
self.mocker.restore()
def test_create_account_groups_without_accounts (self):
dummy_Account = self.mocker.replace('accounting.models.Account')
dummy_Account.objects.all ()
self.mocker.result ([])
self.mocker.count (2)
self.mocker.replay ()
ms = MessageScheduler ({})
ms.create_account_groups()
def test_create_account_groups_with_accounts (self):
dummy_AccountGroup = self.mocker.replace('singularmsd.AccountGroup')
dummy_AccountGroup(ANY)
self.mocker.result (dummy_AccountGroup)
self.mocker.count (3)
dummy_AccountGroup.account.id
self.mocker.result (1)
self.mocker.count (3)
dummy_AccountGroup.start ()
self.mocker.result (True)
self.mocker.count (3)
self.mocker.replay ()
ms = MessageScheduler ({})
ms.create_account_groups()
def test_enqueue_messages_without_messages (self):
dummy_AccountGroup = self.mocker.replace('singularmsd.AccountGroup')
dummy_AccountGroup(ANY)
self.mocker.result (dummy_AccountGroup)
self.mocker.count (3)
dummy_AccountGroup.account.id
self.mocker.result (1)
self.mocker.count (3)
dummy_AccountGroup.start ()
self.mocker.result (True)
self.mocker.count (3)
self.mocker.replay ()
ms = MessageScheduler ({})
ms.create_account_groups()
ms.enqueue_messages ()
def test_enqueue_messages_with_messages_mocker (self):
dummy_AccountGroup = self.mocker.replace('singularmsd.AccountGroup')
dummy_AccountGroup.account.id
self.mocker.result (1)
self.mocker.count (6)
dummy_AccountGroup(ANY)
self.mocker.result (dummy_AccountGroup)
self.mocker.count (6)
dummy_AccountGroup.start ()
self.mocker.result (True)
self.mocker.count (6)
dummy_AccountGroup.event.set ()
self.mocker.result (True)
self.mocker.count (20)
self.mocker.replay ()
ms = MessageScheduler ({})
ms.create_account_groups()
processor = SMSProcessor ()
for i in range (0, 10):
processor.sendSMS (WebServiceTests.username, WebServiceTests.password,
'AccessWithPurchase', 'foo', 'bar', datetime.datetime.now())
for i in range (0, 10):
processor.sendSMSToChannel (WebServiceTests.username, WebServiceTests.password,
'AccessWithPurchase', 'TestChannel', 'bar', datetime.datetime.now())
ms.enqueue_messages ()
class AccountGroupTests (TestCase):
fixtures = ['customer_tests.json', ]
def setUp(self):
self.mocker = Mocker()
def tearDown(self):
self.mocker.restore()
def test_process_from_queue_without_messages (self):
account = Account.objects.get(name = 'AccessWithPurchase')
ag = AccountGroup (account)
retcode = ag.process_from_queue()
self.assertEqual (retcode, False)
def test_process_from_queue_with_messages (self):
ev = threading.Event()
mock_Event = self.mocker.replace(ev)
mock_Event ()
self.mocker.result (mock_Event)
self.mocker.count (3)
mock_Event.set()
self.mocker.result (True)
self.mocker.count (3)
mock_Queue = self.mocker.replace('Queue')
mock_Queue()
self.mocker.result (True)
self.mocker.count (3)
self.mocker.replay ()
ms = MessageScheduler ({})
processor = SMSProcessor ()
for i in range (0, 10):
processor.sendSMS (WebServiceTests.username, WebServiceTests.password,
'AccessWithPurchase', 'foo', 'bar', datetime.datetime.now())
account = Account.objects.get(name = 'AccessWithPurchase')
ag = AccountGroup (account)
ms.account_groups[account.id] = ag
ms.enqueue_messages ()
retcode = ag.process_from_queue()
self.assertEqual (retcode, True)
self.assertEqual (ag.work.qsize (), 10)
def test_create_accountThreads (self):
dummy_AccountThread = self.mocker.replace('singularmsd.AccountThread')
dummy_AccountThread(ANY, ANY)
self.mocker.result (dummy_AccountThread)
self.mocker.count (4)
dummy_AccountThread.num_threads
self.mocker.result (4)
self.mocker.count (4)
dummy_AccountThread.start ()
self.mocker.result (True)
self.mocker.count (4)
self.mocker.replay ()
account = Account.objects.get(name = 'AccessWithPurchase')
ag = AccountGroup (account)
ag.create_accountThreads()
self.assertEqual (len(ag.threads), 4)
class Test_unit_operate_Move_translate(MockerTestCase):
def setUp(self):
self.back_mass_check = operate.Move.mass_check
self.back_calccom = calculate.Calculate.calculate_center_of_mass
self.m = Mocker()
calculate.Calculate.calculate_center_of_mass = self.m.mock()
calculate.Calculate.calculate_center_of_mass(ARGS)
self.m.result(None)
self.m.count(0,None)
operate.Move.mass_check = self.m.mock()
operate.Move.mass_check()
self.m.result(None)
self.m.count(0,None)
self.m.replay()
self.o=system.Molecule(0)
def assert_list_almost_equal(self,a,b,places=5):
if (len(a)!=len(b)):
raise TypeError
else:
for i in range(len(a)):
if isinstance(a[i],(int,float,numpy.generic)):
if (numpy.isnan(a[i]) and numpy.isnan(b[i])): continue
self.assertAlmostEqual(a[i],b[i],places)
else:
self.assert_list_almost_equal(a[i],b[i],places)
def test_one_atom(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.0]]],floattype))
value = numpy.array([1.0, 3.0, 6.0],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[0.0, 5.0, 9.0]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_two_atoms(self):
self.o.setCoor(numpy.array([[[-1.0, 2.0, 3.87],[-5.0, 3.2, 6.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-4.0, 2.0, 9.97],[-8.0, 3.2, 12.1]]], floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, 3.0],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, 9.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf1(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.HUGE],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.HUGE],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_inf2(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.INF],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.INF],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_nan(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.NAN],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.NAN],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_tiny(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.TINY],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, util.TINY+6.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def test_six_atoms_zero(self):
self.o.setCoor(numpy.array([[[1.2, 2.0, util.ZERO],[-2.0, 5.0, 6.0],[7.0, 8.0, 9.0],[1.0, 3.0, 5.0],[2.0, 4.0, 6.0],[0.0, 2.0, 3.0]]],floattype))
value = numpy.array([-3.0, 0.0, 6.1],floattype)
self.o.translate(0,value)
result_coor = self.o.coor()
print result_coor
expected_coor = numpy.array([[[-1.8, 2.0, 6.1],[-5.0, 5.0, 12.1],[4.0, 8.0, 15.1],[-2.0, 3.0, 11.1],[-1.0, 4.0, 12.1],[-3.0, 2.0, 9.1]]],floattype)
self.assert_list_almost_equal(expected_coor, result_coor,3)
def tearDown(self):
self.m.verify()
calculate.Calculate.calculate_center_of_mass=self.back_calccom
operate.Move.mass_check =self.back_mass_check
