def test_process_section(self):
process_function = fudge.Fake()
process_function = (process_function.expects_call()
.with_args(['value1', 'value2', 'value3'])
.returns('fake_return'))
self.config.process_section('list_section', process_function)
assert 'fake_return' == self.config.processed_section('list_section')
def test_kwargs_are_passed_through_to_backend(self):
random_kwargs = dict([("key_%d" % i, i)
for i in range(random.randint(10, 20))])
random_width = random.randint(1000, 2000)
random_height = random.randint(1000, 2000)
embed = object()
settings = fudge.Fake()
settings.has_attr(ARMSTRONG_EMBED_VIDEO_WIDTH=random_width,
ARMSTRONG_EMBED_VIDEO_HEIGHT=random_height)
fake = fudge.Fake()
fake.is_callable().with_args(self, embed, random_width, random_height,
**random_kwargs)
with fudge.patched_context(helpers, "settings", settings):
foo = helpers.inject_defaults(fake)
foo(self, embed, **random_kwargs)
def test_it_builds_basic_product_index_mapping(self):
attributes = (fudge.Fake('MageAttributes').provides(
'getAttributesForEntity').with_args(10).returns([
1, 2
]).provides('getLabel').returns('my_attribute1').next_call(
).returns('my_attribute2').provides('getMappingType').returns(
'string').next_call().returns('integer').provides(
'isSearchable').returns(True).next_call().returns(False))
eq_(
MageIndexMapper(attributes).buildProductIndexMap(), {
"mappings": {
"product": {
"properties": {
"my_attribute1": {
"type": "string",
"index": "analyzed"
},
"my_attribute2": {
"type": "integer",
"index": "not_analyzed"
}
}
}
}
})
def test_get_object_dict_w_keys(self):
obj = fudge.Fake()
obj.test = 123
obj.more = 'yes'
obj._shh = 'quiet'
obj_dict = self.translator.get_object_dict(obj, keys=['more'])
self.assertDictEqual(obj_dict, {'more': 'yes'})
def test_true_if_users_app(self):
user = mommy.make(User)
app = mommy.make(PushApplication, user=user)
mixin = UserOwnsPushAppMixin()
mixin.request = fudge.Fake().has_attr(user=user)
mixin.kwargs = {'pk': app.id}
self.assertTrue(mixin.test_func())
def test_add_requirement(self):
fake_req = fudge.Fake()
fake_req.has_attr(name='fake')
graph = self.graph
graph.add_requirement(fake_req)
deps = graph.get_dependencies(fake_req)
assert deps == []
def get_payment_stub(self, successful=True, response_reason_text="Foobar"):
fake_response = self.get_fake_purchase_response(
successful, response_reason_text)
fake = fudge.Fake()
fake.provides("purchase") \
.returns(fake_response)
return fake
def test_replace_init(self):
class custom_object:
def hello(self):
return "hi"
fake = fudge.Fake().provides("__init__").returns(custom_object())
eq_(fake().hello(), "hi")
def test_is_valid_simple(self):
encoded_response = base64.b64encode(test_response)
res = Response(
response=encoded_response,
signature='foo signature',
)
def fake_clock():
return datetime(2004, 12, 05, 9, 18, 45, 462796)
fake_verifier = fudge.Fake(
'verifier',
callable=True,
)
fake_verifier.times_called(1)
fake_verifier.with_args(res._document, 'foo signature')
fake_verifier.returns(True)
msg = res.is_valid(
_clock=fake_clock,
_verifier=fake_verifier,
)
eq(msg, True)
def test_execute_ok_campaign_id_ok(self, pop3):
mt = MessageTemplate()
mt.save()
c = Campaign()
c.template = mt
c.save()
print(Campaign.objects.all())
raw_message = [
1,
"""MIME-Version: 1.0
Received: by 10.229.233.76 with HTTP; Sat, 2 Jul 2011 04:30:31 -0700 (PDT)
Date: Sat, 2 Jul 2011 13:30:31 +0200
Delivered-To: [email protected]
Message-ID: <CAAJL_=kPAJZ=fryb21wBOALp8-XOEL-h9j84s3SjpXYQjN3Z3A@mail.gmail.com>
Subject: =?ISO-8859-1?Q?Dr.=20Pointcarr=E9?=
From: Alain Spineux <*****@*****.**>
To: =?ISO-8859-1?Q?Dr=2E_Pointcarr=E9?= <*****@*****.**>
Content-Type: multipart/alternative; boundary=000e0cd68f223dea3904a714768b
""" % c.pk
]
mailbox = fudge.Fake() \
.expects('user').returns('response') \
.expects('pass_').returns('test 1') \
.expects('retr').returns(raw_message) \
.provides('dele').returns(True) \
.expects('quit').returns(True)
pop3.is_callable().returns(mailbox)
settings.EMAIL_UNSUBSCRIBE_SECRET_KEY = ''
settings.MASSMAIL_UNSUBSCRIBE_MAILBOX_POP_SERVER = ''
settings.MASSMAIL_UNSUBSCRIBE_EMAIL = ''
settings.MASSMAIL_UNSUBSCRIBE_MAILBOX_PASSWORD = '******'
self.command.handle()
def test_execute_bad_signature(self, pop3):
raw_message = [
1, """MIME-Version: 1.0
Received: by 10.229.233.76 with HTTP; Sat, 2 Jul 2011 04:30:31 -0700 (PDT)
Date: Sat, 2 Jul 2011 13:30:31 +0200
Delivered-To: [email protected]
Message-ID: <CAAJL_=kPAJZ=fryb21wBOALp8-XOEL-h9j84s3SjpXYQjN3Z3A@mail.gmail.com>
Subject: =?ISO-8859-1?Q?Dr.=20Pointcarr=E9?=
From: Alain Spineux <*****@*****.**>
To: =?ISO-8859-1?Q?Dr=2E_Pointcarr=E9?= <*****@*****.**>
Content-Type: multipart/alternative; boundary=000e0cd68f223dea3904a714768b
"""
]
mailbox = fudge.Fake() \
.expects('user').returns('response') \
.expects('pass_').returns('test 1') \
.expects('retr').returns(raw_message) \
.provides('dele').returns(True) \
.expects('quit').returns(True)
pop3.is_callable().returns(mailbox)
settings.EMAIL_UNSUBSCRIBE_SECRET_KEY = ''
settings.MASSMAIL_UNSUBSCRIBE_MAILBOX_POP_SERVER = ''
settings.MASSMAIL_UNSUBSCRIBE_EMAIL = ''
settings.MASSMAIL_UNSUBSCRIBE_MAILBOX_PASSWORD = '******'
self.command.handle()
def check_expectation(self, setter, value, error=None, exclude=None):
"""
Call setter with a single keyword argument set to value for each keyword argument accepted
If error is specified, then we check that ConfigurationError with error as a message is risen
Otherwise we check value was set on the options
"""
if exclude is None:
exclude = []
requirements = self.specification[setter]
if exclude:
requirements = [requirement for requirement in requirements if requirement not in exclude]
old = fudge.Fake("old")
options = Options()
for requirement in requirements:
kwargs = {requirement:value}
setattr(options, requirement, old)
caller = lambda : setter(options, **kwargs)
if error:
caller |should| throw(ConfigurationError, message=error % {'name' : requirement})
getattr(options, requirement) |should| be(old)
else:
caller()
getattr(options, requirement) |should| be(value)
def test_get_by_url_doesnt_create_bid(self):
url = 'https://github.com/codesy/codesy/issues/419'
self.view.request = (fudge.Fake().has_attr(GET={
'url': url
}).has_attr(user=self.user1))
context = self.view.get_context_data()
self.assertIsNone(context['bid'])
def setUpPackage(self):
# mock stripe Customer
mock_id = fudge.Fake().has_attr(id='dammit')
mock_customer = (fudge.Fake().provides('create').returns(mock_id))
self.patch_stripe = fudge.patch_object('payments.utils.stripe', 'Customer',
mock_customer)
# mock stripe Event
evt_resp = json.loads(payment_created)
mock_event = (fudge.Fake().provides('retrieve').has_attr(
verified=True).returns(evt_resp))
self.patch_stripe = fudge.patch_object('payments.utils.stripe', 'Event',
mock_event)
# mock stripe account_id
setup_mock_account(verification=account_verified)
def test_can_communicate_with_real_authorize_backend_for_recurring(self):
onetime_purchase = fudge.Fake().is_callable().returns({"status": True})
class TestableApi(arb.Api):
def __init__(self, *args, **kwargs):
kwargs["is_test"] = True
super(TestableApi, self).__init__(*args, **kwargs)
def create_subscription(self, **kwargs):
kwargs["test_request"] = u"TRUE"
return super(TestableApi, self).create_subscription(**kwargs)
donation, donation_form = self.random_donation_and_form
donation_form.data["card_number"] = u"4222222222222" # Set to test CC
donation.donation_type = self.random_monthly_type
donation.amount = 1
backend = backends.AuthorizeNetBackend(recurring_api_class=TestableApi,
settings=self.test_settings)
with fudge.patched_context(backend, "onetime_purchase",
onetime_purchase):
result = backend.purchase(donation, donation_form)
try:
self.assertTrue(result["status"])
except AssertionError:
# This is a known issue where Authorize.net randomly returns
# a bad response in test mode. Yup, you read that correctly.
# A system designed to process your money can't actually figure
# out how to run a test server in a reliable wayself.
self.assertEqual(result["reason"],
u"(TESTMODE) The credit card number is invalid.",
msg="Authorize.net really has failed us")
def test_delete_known_track(self):
resp = self.client.get(reverse('playlists_landing_page'))
context = resp.context[0]
tracks = [t for t in context['playlist_events']]
self.assertEquals(tracks[0].artist_name, "Steely Dan")
def inspect_request(r):
self.assertEqual(
r.get_full_url(),
'http://testapi/playlist/delete/%s' % self.track.key())
self.assertEqual(r.http_method, 'DELETE')
return True
fake_urlopen = (fudge.Fake('urlopen', expect_call=True).with_args(
arg.passes_test(inspect_request)))
fake_response = (fake_urlopen.returns_fake().has_attr(
code='200').provides('read').returns("<service response>"))
with fudge.patched_context(playlists.tasks.urllib2, "urlopen",
fake_urlopen):
resp = self.client.get(
reverse('playlists_delete_event', args=[self.track.key()]))
self.assertRedirects(resp, reverse('playlists_landing_page'))
# simulate the redirect:
resp = self.client.get(reverse('playlists_landing_page'))
context = resp.context[0]
tracks = [t for t in context['playlist_events']]
self.assertEquals(tracks, [])
def test_adds_recurring_response_to_return_on_failure(self):
random_return = random.randint(1000, 2000)
donation, donation_form = self.random_donation_and_form
donation.donation_type = self.random_monthly_type
recurring_purchase = (
fudge.Fake().is_callable().returns(random_return))
onetime_purchase = (fudge.Fake().is_callable().returns(
{"status": True}))
backend = backends.AuthorizeNetBackend()
with stub_recurring_purchase(backend, recurring_purchase):
with stub_onetime_purchase(backend, onetime_purchase):
result = backend.purchase(donation, donation_form)
self.assertTrue("recurring_response" in result)
self.assertEqual(result["recurring_response"], random_return)
def test_create_not_latin_chars(self):
def inspect_request(r):
# NOTE: due to URL fetching, you can only raise
# AssertionError here
self.assertEqual(
r.get_full_url(),
'http://__dummylive365service__/cgi-bin/add_song.cgi')
qs = dict(cgi.parse_qsl(r.data))
self.assertEqual(qs['member_name'], "dummy_member")
self.assertEqual(qs['password'], "dummy_password")
self.assertEqual(qs['seconds'], '30')
# c should be replaced because latin-1 can't encode that and Live365 likes latin-1
self.assertEqual(qs['title'], 'Ivan Krsti song')
self.assertEqual(qs['album'], 'Ivan Krsti album')
self.assertEqual(qs['artist'], 'Ivan Krsti')
return True
fake_urlopen = (fudge.Fake('urlopen', expect_call=True).with_args(
arg.passes_test(inspect_request)))
fake_response = (fake_urlopen.returns_fake().has_attr(
code='200').provides('read').returns("<service response>"))
with fudge.patched_context(playlists.tasks.urllib2, "urlopen",
fake_urlopen):
resp = self.client.post(reverse('playlists.send_track_to_live365'),
{'id': self.track.key()})
fudge.verify()
def testCanAddALineItem(self):
fakeLineItem = (fudge.Fake('LineItem').has_attr(item_id="foo",
quantity=0))
fixture = shop.Shopper(MockCart())
self.assertEqual('foo', fixture.add(fakeLineItem))
self.failUnless(fixture.contains("foo"))
def test_config_util_initialisation():
'''Test ConfigUtil initialises properly'''
template = fudge.Fake("template")
config_util = ConfigUtil(template)
config_util.values |should| equal_to({})
config_util.template |should| be(template)
def test_get_object_not_exists(self):
self.translator.model = fudge.Fake().is_a_stub()
self.translator.model.expects_call().returns('initialized object')
obj = self.translator.get_object(stuff='things')
self.assertEqual(obj, 'initialized object')
def inner(self, *args, **kwargs):
donation, form = self.random_donation_and_form
fake_save = fudge.Fake().is_callable().returns(donation)
setattr(form, "save", fake_save)
v = self.get_post_view(confirmed=confirmed)
response = v.form_is_valid(form)
func(self, response)
def setUp(self):
self.user = mommy.make(User)
self.app = mommy.make(PushApplication, user=self.user)
self.request = fudge.Fake().has_attr(user=self.user,
POST={"signed_token": True})
self.view = Validation()
self.view.request = self.request
def test_status_can_be_cleared(self):
bot = Bot('user@server', 'pass')
bot.logs['first'] = Log('/tmp/jabber_test/first.log')
bot.logs['secnd'] = Log('/tmp/jabber_test/secnd.log')
bot.status = lambda: ('', 'Ok')
bot.client = fudge.Fake('client').is_a_stub()
filename1 = '/tmp/jabber_test/first.log'
log1 = Log('first')
self.set_date('2011-09-21 01:00:03')
open(filename1,
'w').write('2011-09-21 01:00:01,854 - first - INFO - Line 01\n')
# Status should be 'Ok'
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:03 Ok')
self.assertEquals(bot.status_show, '')
# Error will change status
self.set_date('2011-09-21 01:00:05')
open(filename1,
'a').write('2011-09-21 01:00:04,854 - first - ERROR - Error 01\n')
bot.cycle()
self.assertEquals(bot.status_msg,
'2011-09-21 01:00:04 first: Error 01')
self.assertEquals(bot.status_show, 'dnd')
bot.clear()
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:03 Ok')
self.assertEquals(bot.status_show, '')
def test_adds_app_to_context_data(self):
user = mommy.make(User)
app = mommy.make(PushApplication, user=user)
mixin = UserOwnsPushAppMixin()
mixin.request = fudge.Fake().has_attr(user=user)
context = mixin.get_context_data(pk=app.id)
self.assertEqual(app, context['app'])
def test_status_show_time_when_status_was_last_changed(self):
bot = Bot('user@server', 'pass')
bot.status = lambda: ('', 'Ok')
bot.client = fudge.Fake('client').is_a_stub()
self.set_date('2011-09-21 01:00:03')
# Status should be 'Ok'
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:03 Ok')
self.assertEquals(bot.status_show, '')
# Status change should reflect in bot's status, with new time
self.set_date('2011-09-21 01:00:04')
bot.status = lambda: ('away', 'Other status')
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:04 Other status')
self.assertEquals(bot.status_show, 'away')
# New time won't change status time if message is not changed
self.set_date('2011-09-21 01:00:05')
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:04 Other status')
self.assertEquals(bot.status_show, 'away')
# Status will be changed now
self.set_date('2011-09-21 01:00:06')
bot.status = lambda: ('away', 'New status')
bot.cycle()
self.assertEquals(bot.status_msg, '2011-09-21 01:00:06 New status')
self.assertEquals(bot.status_show, 'away')
def test_shortname_default(self):
r = remote.Remote(
name='*****@*****.**',
ssh=fudge.Fake('SSHConnection'),
)
assert r.shortname == 'xyzzy'
assert str(r) == '*****@*****.**'
def test_shortname_default():
r = remote.Remote(
name='*****@*****.**',
ssh=fudge.Fake('SSHConnection'),
)
eq(r.shortname, '*****@*****.**')
eq(str(r), '*****@*****.**')
def test_runner_lists_commands(self):
fake_registry = fudge.Fake()
(fake_registry.expects('list_commands')
.returns(['command1', 'command2']))
self.runner.set_registry(fake_registry)
commands = self.runner.list_commands()
assert commands == ['command1', 'command2']
def test_pre_save_sets_user_to_request_user(self):
user, url, issue, claim = _make_test_claim()
self.viewset.request = fudge.Fake().has_attr(user=user)
self.viewset.pre_save(claim)
self.assertEqual(claim.user, user)
